require-hacker/babel-transpiled-modules/require hacker.js

// Hacking too much time

// Based on Node.js Module class sources:
// https://github.com/nodejs/node/blob/master/lib/module.js

'use strict';

var _classCallCheck = require('babel-runtime/helpers/class-call-check')['default'];

var _getIterator = require('babel-runtime/core-js/get-iterator')['default'];

var _Set = require('babel-runtime/core-js/set')['default'];

var _interopRequireDefault = require('babel-runtime/helpers/interop-require-default')['default'];

exports.__esModule = true;

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

var _path2 = require('path');

var _path3 = _interopRequireDefault(_path2);

var _module2 = require('module');

var _module3 = _interopRequireDefault(_module2);

var _toolsLog = require('./tools/log');

var _toolsLog2 = _interopRequireDefault(_toolsLog);

var _helpers = require('./helpers');

var _toolsSerializeJavascript = require('./tools/serialize-javascript');

var _toolsSerializeJavascript2 = _interopRequireDefault(_toolsSerializeJavascript);

var original_findPath = _module3['default']._findPath;

var Require_hacker = (function () {
	function Require_hacker(options) {
		var _this = this;

		_classCallCheck(this, Require_hacker);

		this.preceding_abstract_path_resolvers = [];
		this.abstract_path_resolvers = [];
		this.abstract_path_resolved_modules = {};

		// // take the passed in options
		// this.options = clone(options)

		// logging
		this.log = new _toolsLog2['default']('require-hook', { debug: options.debug }); // this.options.debug

		// instrument Module._findPath
		// https://github.com/nodejs/node/blob/master/lib/module.js#L335-L341
		_module3['default']._findPath = function () {
			for (var _len = arguments.length, parameters = Array(_len), _key = 0; _key < _len; _key++) {
				parameters[_key] = arguments[_key];
			}

			var request = parameters[0];
			// const paths = parameters[1]

			// preceeding resolvers
			for (var _iterator = _this.preceding_abstract_path_resolvers, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _getIterator(_iterator);;) {
				var _ref;

				if (_isArray) {
					if (_i >= _iterator.length) break;
					_ref = _iterator[_i++];
				} else {
					_i = _iterator.next();
					if (_i.done) break;
					_ref = _i.value;
				}

				var resolver = _ref;

				var resolved = resolver.resolve(request);
				if (typeof resolved !== 'undefined') {
					return resolved;
				}
			}

			// original Node.js loader
			var filename = original_findPath.apply(undefined, parameters);
			if (filename !== false) {
				return filename;
			}

			// rest resolvers
			for (var _iterator2 = _this.abstract_path_resolvers, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _getIterator(_iterator2);;) {
				var _ref2;

				if (_isArray2) {
					if (_i2 >= _iterator2.length) break;
					_ref2 = _iterator2[_i2++];
				} else {
					_i2 = _iterator2.next();
					if (_i2.done) break;
					_ref2 = _i2.value;
				}

				var resolver = _ref2;

				var resolved = resolver.resolve(request);
				if (typeof resolved !== 'undefined') {
					return resolved;
				}
			}

			return false;
		};
	}

	// validation

	// installs a require() hook for paths
	// which don't exist in the filesystem
	//
	// (if these paths exist in the filesystem
	//  then use the .hook(extension, resolve) method instead)
	//
	// id - a meaningful textual identifier
	//
	// resolver - a function which takes two parameters:
	//
	//              the path to be resolved
	//
	//              a function which flushes require() cache for this path
	//              with no parameters
	//
	//            must return a javascript CommonJS module source code
	//            (i.e. "module.exports = ...", etc)
	//
	// returns an object with an .undo() method
	//

	Require_hacker.prototype.global_hook = function global_hook(id, resolver) {
		var _this2 = this;

		var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];

		validate.global_hook(id, resolver);

		var resolver_entry = {
			id: id,
			resolve: function resolve(path) {
				var resolved_path = path + '.' + id;

				// CommonJS module source code
				var source = resolver(path);

				if (!_helpers.exists(source)) {
					return;
				}

				// const flush_cache = () => delete require.cache[resolved_path]
				delete require.cache[resolved_path];

				_this2.abstract_path_resolved_modules[resolved_path] = source;

				return resolved_path;
			}
		};

		if (options.precede_node_loader) {
			this.preceding_abstract_path_resolvers.push(resolver_entry);
		} else {
			this.abstract_path_resolvers.push(resolver_entry);
		}

		var hook = this.hook(id, function (path) {
			var source = _this2.abstract_path_resolved_modules[path];
			delete _this2.abstract_path_resolved_modules[path];
			return source;
		});

		var result = {
			unmount: function unmount() {
				// javascript arrays still have no .remove() method in the XXI-st century
				_this2.preceding_abstract_path_resolvers = _this2.preceding_abstract_path_resolvers.filter(function (x) {
					return x !== resolver_entry;
				});
				_this2.abstract_path_resolvers = _this2.abstract_path_resolvers.filter(function (x) {
					return x !== resolver_entry;
				});
				hook.unmount();
			}
		};

		return result;
	};

	// installs a require() hook for the extension
	//
	// extension - a file extension to hook into require()s of
	//             (examples: 'css', 'jpg', 'js')
	//
	// resolve   - a function that takes two parameters:
	//
	//               the path requested in the require() call
	//
	//               and a fallback function (fall back to default behaviour)
	//               with no parameters
	//
	//             must return a javascript CommonJS module source code
	//             (i.e. "module.exports = ...", etc)
	//

	Require_hacker.prototype.hook = function hook(extension, resolve) {
		var _this3 = this;

		this.log.debug('Hooking into *.' + extension + ' files loading');

		// validation
		validate.extension(extension);
		validate.resolve(resolve);

		// dotted extension
		var dot_extension = '.' + extension;

		// keep original extension loader
		var original_loader = _module3['default']._extensions[dot_extension];

		// display a warning in case of extension loader override
		if (original_loader) {
			// output a debug message in case of extension loader override,
			// not a warning, so that it doesn't scare people
			this.log.debug('-----------------------------------------------');
			this.log.debug('Overriding an already existing require() hook ');
			this.log.debug('for file extension ' + dot_extension);
			this.log.debug('-----------------------------------------------');
		}

		// the list of cached modules
		var cached_modules = new _Set();

		// set new loader for this extension
		_module3['default']._extensions[dot_extension] = function (module, filename) {
			_this3.log.debug('Loading source code for ' + filename);

			// fallback flag
			var aborted = false;

			// var source = fs.readFileSync(filename, 'utf8')
			var source = resolve(filename, function () {
				_this3.log.debug('Fallback to original loader');

				// fallen back
				aborted = true;

				// this message would appear if there was no loader
				// for the extension of the filename
				if (_path3['default'].extname(filename) !== dot_extension) {
					_this3.log.info('Trying to load "' + _path3['default'].basename(filename) + '" as a "*' + dot_extension + '"');
				}

				// load the file with the original loader
				(original_loader || _module3['default']._extensions['.js'])(module, filename);
			});

			// if fallen back - exit
			if (aborted) {
				return;
			}

			// add this file path to the list of cached modules
			cached_modules.add(filename);

			// compile javascript module from its source
			// https://github.com/nodejs/node/blob/master/lib/module.js#L379
			module._compile(source, filename);
		};

		var result = {
			// uninstall the hook
			unmount: function unmount() {
				// clear require() cache for this file extension
				for (var _iterator3 = cached_modules, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _getIterator(_iterator3);;) {
					var _ref3;

					if (_isArray3) {
						if (_i3 >= _iterator3.length) break;
						_ref3 = _iterator3[_i3++];
					} else {
						_i3 = _iterator3.next();
						if (_i3.done) break;
						_ref3 = _i3.value;
					}

					var _path = _ref3;

					delete require.cache[_path];
				}

				// mount the original loader for this file extension
				_module3['default']._extensions[dot_extension] = original_loader;
			}
		};

		return result;
	};

	// // uninstalls a previously installed require() hook for the extension
	// //
	// // extension - the file extension for which to uninstall
	// //             the previously installed require() hook
	// //
	// unhook(extension)
	// {
	// 	this.log.debug(`Unhooking from .${extension} files loading`)
	//
	// 	// validation
	// 	validate.extension(extension)
	//
	// 	// dotted extension
	// 	const dot_extension = `.${extension}`
	//
	// 	// verify that the hook exists in the first place
	// 	if (Object.keys(this.original_loaders).indexOf(dot_extension) < 0)
	// 	{
	// 		throw new Error(`Require() hook wasn't previously installed for ${dot_extension} files`)
	// 	}
	//
	// 	// uninstall the hook
	// 	Module._extensions[dot_extension] = this.original_loaders[dot_extension]
	// 	delete this.original_loaders[dot_extension]
	// }
	return Require_hacker;
})();

exports['default'] = Require_hacker;
var validate = {
	extension: function extension(_extension) {
		// if (typeof extension !== 'string')
		// {
		// 	throw new Error(`Expected string extension. Got ${extension}`)
		// }

		if (_path3['default'].extname('test.' + _extension) !== '.' + _extension) {
			throw new Error('Invalid file extension ' + _extension);
		}
	},

	resolve: function resolve(_resolve) {
		if (typeof _resolve !== 'function') {
			throw new Error('Resolve should be a function. Got ' + _resolve);
		}
	},

	global_hook: function global_hook(id, resolver) {
		if (!id) {
			throw new Error('You must specify global hook id');
		}

		if (_path3['default'].extname('test.' + id) !== '.' + id) {
			throw new Error('Invalid global hook id. Expected a valid file extension.');
		}

		validate.resolve(resolver);
	}
};

// returns a CommonJS modules source.
Require_hacker.to_javascript_module_source = function (anything) {
	// if the asset source wasn't found - return an empty CommonJS module
	if (!_helpers.exists(anything)) {
		return 'module.exports = undefined';
	}

	// if it's already a common js module source
	if (typeof anything === 'string' && is_a_module_declaration(anything)) {
		return anything;
	}

	// generate javascript module source code based on the `source` variable
	return 'module.exports = ' + _toolsSerializeJavascript2['default'](anything);
};

// detect if it is a CommonJS module declaration
function is_a_module_declaration(text) {
	return text.indexOf('module.exports = ') === 0 || /\s+module\.exports = .+/.test(text);
}
module.exports = exports['default'];

// original_loaders = {}
//# sourceMappingURL=require hacker.js.map